import 'package:flutter/foundation.dart';
import 'package:get/get.dart';
import '../models/index.dart';
import '../utils/encryption_util.dart';
import '../services/dio_service.dart';
import '../services/points_permission_service.dart';
import '../services/user_service.dart';

/// 好友相关API接口
/// 
/// 提供好友列表、好友申请等相关的API调用方法
class FriendApi {
  static const String tag = 'FriendApi';
  
  // 📡 网络服务实例
  static DioService get _dioService => Get.find<DioService>();

  /// 🔥 获取好友列表（AES加密）
  /// 
  /// 参考小程序实现：wanzhende-m/miniprogram/utils/api.js getFriendList
  /// 
  /// @param request 好友列表请求参数
  /// @returns 好友列表（包含好友数量和好友列表数据）
  static Future<Map<String, dynamic>> getFriendList(FriendListReq request) async {
    try {
      debugPrint('$tag: =============== 获取好友列表（AES加密） ===============');
      debugPrint('$tag: 👤 用户ID: ${request.userId}');
      debugPrint('$tag: 📁 分组ID: ${request.groupId ?? "全部"}');
      debugPrint('$tag: 📊 状态筛选: ${request.status ?? "全部"}');
      
      // 构建请求数据（与小程序保持一致）
      final requestData = request.toJson();
      
      debugPrint('$tag: 📊 请求参数（加密前）: $requestData');
      
      // AES 加密
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(requestData);
      debugPrint('$tag: 🔐 加密载荷已生成');
      
      // 发送POST请求到 /friends/list/
      final response = await _dioService.post(
        '/friends/list/',
        data: encryptedPayload,
      );
      
      // 获取响应数据
      final responseData = response.data as Map<String, dynamic>;
      
      debugPrint('$tag: ✅ 好友列表获取成功');
      debugPrint('$tag: 👥 好友数量: ${responseData['count'] ?? 0}');
      
      // 解析好友列表
      final List<FriendEntity> friendList = [];
      if (responseData['data'] != null && responseData['data'] is List) {
        for (var item in responseData['data']) {
          try {
            final friend = FriendEntity.fromJson(item as Map<String, dynamic>);
            friendList.add(friend);
            debugPrint('$tag:   👤 ${friend.username ?? "未知"} (ID: ${friend.friendId})');
          } catch (e) {
            debugPrint('$tag: ⚠️ 解析好友数据失败: $e');
          }
        }
      }
      
      debugPrint('$tag: 📝 成功解析 ${friendList.length} 个好友');
      
      // 返回统一格式
      return {
        'status': 'success',
        'count': responseData['count'] ?? friendList.length,
        'data': friendList,
        'message': responseData['message'] ?? '获取好友列表成功',
      };
      
    } catch (e) {
      debugPrint('$tag: ❌ 获取好友列表失败: $e');
      rethrow;
    }
  }
  
  /// 🔥 获取好友申请列表（AES加密）
  /// 
  /// 参考 playtrue3 实现：使用 /friends/request_list/ 接口
  /// 
  /// @param userId 用户ID
  /// @returns 好友申请列表（包含申请数量和申请列表数据）
  static Future<Map<String, dynamic>> getFriendRequestList(int userId) async {
    try {
      debugPrint('$tag: =============== 获取好友申请列表（AES加密） ===============');
      debugPrint('$tag: 👤 用户ID: $userId');
      
      // 构建请求数据（与 playtrue3 保持一致）
      final requestData = {
        'user_id': userId,  // 使用下划线格式
        'timestamp': DateTime.now().millisecondsSinceEpoch ~/ 1000,
      };
      
      debugPrint('$tag: 📊 请求参数（加密前）: $requestData');
      
      // AES 加密
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(requestData);
      debugPrint('$tag: 🔐 加密载荷已生成');
      
      // ✅ 修复：使用正确的接口地址 /friends/request_list/ （与 playtrue3 一致）
      final response = await _dioService.post(
        '/friends/request_list/',
        data: encryptedPayload,
      );
      
      // 获取响应数据
      final responseData = response.data as Map<String, dynamic>;
      
      debugPrint('$tag: ✅ 好友申请列表获取成功');
      debugPrint('$tag: 📬 申请数量: ${responseData['count'] ?? 0}');
      
      // 解析好友申请列表
      final List<FriendRequestEntity> requestList = [];
      if (responseData['data'] != null && responseData['data'] is List) {
        for (var item in responseData['data']) {
          try {
            final request = FriendRequestEntity.fromJson(item as Map<String, dynamic>);
            requestList.add(request);
            debugPrint('$tag:   📬 来自 ${request.senderName ?? "未知"} (ID: ${request.senderId}) - 状态: ${request.statusText}');
          } catch (e) {
            debugPrint('$tag: ⚠️ 解析好友申请数据失败: $e');
            debugPrint('$tag:   原始数据: $item');
          }
        }
      }
      
      debugPrint('$tag: 📝 成功解析 ${requestList.length} 个好友申请');
      
      // 返回统一格式
      return {
        'status': 'success',
        'count': responseData['count'] ?? requestList.length,
        'data': requestList,
        'message': responseData['message'] ?? '获取好友申请列表成功',
      };
      
    } catch (e) {
      debugPrint('$tag: ❌ 获取好友申请列表失败: $e');
      rethrow;
    }
  }
  
  /// 🔥 发送好友申请（AES加密）
  /// 
  /// 参考小程序实现：wanzhende-m/miniprogram/utils/api.js sendFriendRequest
  /// ✅ 修复：移除重复扣除积分的逻辑
  /// 积分扣除由后端根据free参数自动处理
  /// 
  /// @param senderId 发送者ID
  /// @param receiverId 接收者ID
  /// @param message 申请消息（可选）
  /// @param checkPermission 是否检查积分权限（默认true）
  /// @returns 发送结果
  static Future<Map<String, dynamic>> sendFriendRequest({
    required int senderId,
    required int receiverId,
    String? message,
    bool checkPermission = true,
  }) async {
    try {
      debugPrint('$tag: =============== 发送好友申请（AES加密） ===============');
      debugPrint('$tag: 👤 发送者ID: $senderId');
      debugPrint('$tag: 👤 接收者ID: $receiverId');
      debugPrint('$tag: 💬 申请消息: ${message ?? "无"}');
      debugPrint('$tag: 🎯 检查权限: $checkPermission');
      
      int free = 1;  // 默认免费
      
      // 🔥 检查积分权限（如果启用）
      if (checkPermission) {
        try {
          final pointsPermissionService = Get.find<PointsPermissionService>();
          
          // 计算是否免费
          free = pointsPermissionService.calculateAddFriendFree();
          
          debugPrint('$tag: 💰 权限计算结果: ${free == 1 ? "免费" : "付费"}');
          
          // ✅ 如果需要付费，检查积分是否足够（不扣除，由后端处理）
          if (free == 0) {
            final cost = pointsPermissionService.addFriendCost.value;
            final actualCost = cost == 0 ? 3 : cost;
            
            final userService = Get.find<UserService>();
            final currentPoints = userService.userInfo?.userPoints ?? 0;
            
            if (currentPoints < actualCost) {
              throw Exception('积分不足，加好友需要${actualCost}积分');
            }
            
            debugPrint('$tag: 💸 需要扣除积分: $actualCost（由后端处理）');
          }
        } catch (e) {
          debugPrint('$tag: ❌ 积分权限检查失败: $e');
          // 🔥 积分不足或权限检查失败，提取纯文本消息后抛出
          final errorMessage = e.toString().replaceAll('Exception: ', '');
          throw Exception(errorMessage);
        }
      }
      
      // 🔥 发送好友申请
      final requestData = {
        'sender_id': senderId,
        'receiver_id': receiverId,
        'message': message ?? '我想加你为好友',
        'free': free,
        'timestamp': DateTime.now().millisecondsSinceEpoch ~/ 1000,
      };
      
      debugPrint('$tag: 📊 请求参数（加密前）: $requestData');
      
      // AES 加密
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(requestData);
      debugPrint('$tag: 🔐 加密载荷已生成');
      
      // 发送POST请求到 /friends/send_request/
      final response = await _dioService.post(
        '/friends/send_request/',
        data: encryptedPayload,
      );
      
      // 获取响应数据
      final responseData = response.data as Map<String, dynamic>;
      
      debugPrint('$tag: 📝 后端响应: ${responseData['message']}');
      
      // 🔥 检查后端返回状态
      final backendStatus = responseData['status'];
      
      // ❌ 如果后端返回error，直接返回error（不增加统计，不更新积分）
      if (backendStatus == 'error') {
        debugPrint('$tag: ⚠️ 后端返回错误: ${responseData['message']}');
        return {
          'status': 'error',
          'message': responseData['message'] ?? '好友申请发送失败',
        };
      }
      
      debugPrint('$tag: ✅ 好友申请发送成功');
      
      // ✅ 只有成功时才更新本地积分
      final pointsChange = responseData['points_change'] ?? 0;
      if (pointsChange != 0) {
        try {
          final userService = Get.find<UserService>();
          final currentPoints = userService.userInfo?.userPoints ?? 0;
          final newPoints = currentPoints + (pointsChange is int ? pointsChange : (pointsChange as num).toInt());
          userService.updateUserPoints(newPoints);
          debugPrint('$tag: ✅ 本地用户积分已更新: $currentPoints -> $newPoints (变化: $pointsChange)');
        } catch (e) {
          debugPrint('$tag: ⚠️ 更新本地积分失败: $e');
        }
      }
      
      // ✅ 只有真正成功时才增加统计
      if (checkPermission) {
        try {
          final pointsPermissionService = Get.find<PointsPermissionService>();
          pointsPermissionService.incrementAddFriendCount();
          debugPrint('$tag: ✅ 加好友次数统计已更新');
        } catch (e) {
          debugPrint('$tag: ⚠️ 更新加好友次数失败: $e');
        }
      }
      
      // 返回统一格式
      return {
        'status': backendStatus ?? 'success',  // 🔥 使用后端返回的状态
        'message': responseData['message'] ?? '好友申请发送成功',
        'request_id': responseData['request_id'],
        'points_change': pointsChange,  // ✅ 返回积分变化
      };
      
    } catch (e) {
      debugPrint('$tag: ❌ 发送好友申请失败: $e');
      rethrow;
    }
  }
  
  /// 🔥 处理好友申请（AES加密）
  /// 
  /// 参考 playtrue3 实现：handleFriendRequest
  /// 
  /// @param requestId 申请ID
  /// @param action 操作类型（"accept"=同意, "reject"=拒绝, "ignore"=忽略）
  /// @returns 处理结果
  static Future<Map<String, dynamic>> handleFriendRequest({
    required int requestId,
    required String action,
  }) async {
    try {
      debugPrint('$tag: =============== 处理好友申请（AES加密） ===============');
      debugPrint('$tag: 📝 申请ID: $requestId');
      debugPrint('$tag: 🎯 操作类型: $action');
      
      // 验证操作类型
      if (!['accept', 'reject', 'ignore'].contains(action)) {
        throw ArgumentError('无效的操作类型: $action');
      }
      
      // 构建请求数据（与 playtrue3 保持一致）
      final requestData = {
        'request_id': requestId,
        'action': action,
        'timestamp': DateTime.now().millisecondsSinceEpoch ~/ 1000,
      };
      
      debugPrint('$tag: 📊 请求参数（加密前）: $requestData');
      
      // AES 加密
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(requestData);
      debugPrint('$tag: 🔐 加密载荷已生成');
      
      // 发送POST请求到 /friends/handle_request/
      final response = await _dioService.post(
        '/friends/handle_request/',
        data: encryptedPayload,
      );
      
      // 获取响应数据
      final responseData = response.data as Map<String, dynamic>;
      
      debugPrint('$tag: ✅ 好友申请处理成功');
      debugPrint('$tag: 📝 消息: ${responseData['message']}');
      if (responseData['friendship_id'] != null) {
        debugPrint('$tag: 🤝 好友关系ID: ${responseData['friendship_id']}');
      }
      
      // 返回统一格式
      return {
        'status': 'success',
        'message': responseData['message'] ?? '好友申请处理成功',
        'friendship_id': responseData['friendship_id'],
      };
      
    } catch (e) {
      debugPrint('$tag: ❌ 处理好友申请失败: $e');
      rethrow;
    }
  }
  
  /// 🔥 删除好友（AES加密）
  /// 
  /// 参考 playtrue3 实现：deleteFriend
  /// 
  /// @param userId 用户ID
  /// @param friendId 好友ID
  /// @returns 删除结果
  static Future<Map<String, dynamic>> deleteFriend({
    required int userId,
    required int friendId,
  }) async {
    try {
      debugPrint('$tag: =============== 删除好友（AES加密） ===============');
      debugPrint('$tag: 👤 用户ID: $userId');
      debugPrint('$tag: 👤 好友ID: $friendId');
      
      // 构建请求数据（与 playtrue3 保持一致）
      final requestData = {
        'user_id': userId,
        'friend_id': friendId,
        'timestamp': DateTime.now().millisecondsSinceEpoch ~/ 1000,
      };
      
      debugPrint('$tag: 📊 请求参数（加密前）: $requestData');
      
      // AES 加密
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(requestData);
      debugPrint('$tag: 🔐 加密载荷已生成');
      
      // 发送POST请求到 /friends/delete/
      final response = await _dioService.post(
        '/friends/delete/',
        data: encryptedPayload,
      );
      
      // 获取响应数据
      final responseData = response.data as Map<String, dynamic>;
      
      debugPrint('$tag: ✅ 好友删除成功');
      debugPrint('$tag: 📝 消息: ${responseData['message']}');
      
      // 返回统一格式
      return {
        'status': 'success',
        'message': responseData['message'] ?? '好友删除成功',
      };
      
    } catch (e) {
      debugPrint('$tag: ❌ 删除好友失败: $e');
      rethrow;
    }
  }
  
  /// 🔥 检查好友关系（AES加密）
  /// 
  /// 参考小程序实现：wanzhende-m/miniprogram/utils/api.js checkFriendRelationship
  /// 
  /// @param userId 用户ID
  /// @param targetUserId 目标用户ID
  /// @returns 关系状态
  static Future<Map<String, dynamic>> checkFriendRelationship({
    required int userId,
    required int targetUserId,
  }) async {
    try {
      debugPrint('$tag: =============== 检查好友关系（AES加密） ===============');
      debugPrint('$tag: 👤 用户1 ID: $userId');
      debugPrint('$tag: 👤 用户2 ID: $targetUserId');
      
      // 构建请求数据（与小程序保持一致：使用 user1_id 和 user2_id）
      final requestData = {
        'user1_id': userId.toString(),
        'user2_id': targetUserId.toString(),
        'timestamp': DateTime.now().millisecondsSinceEpoch ~/ 1000,
      };
      
      debugPrint('$tag: 📊 请求参数（加密前）: $requestData');
      
      // AES 加密
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(requestData);
      debugPrint('$tag: 🔐 加密载荷已生成');
      
      // 发送POST请求到 /friends/check_relationship/
      final response = await _dioService.post(
        '/friends/check_relationship/',
        data: encryptedPayload,
      );
      
      // 获取响应数据
      final responseData = response.data as Map<String, dynamic>;
      
      debugPrint('$tag: ✅ 好友关系查询成功');
      debugPrint('$tag: 📊 关系状态: ${responseData['data']}');
      
      // 返回统一格式
      return {
        'status': 'success',
        'data': responseData['data'],
        'message': responseData['message'] ?? '查询成功',
      };
      
    } catch (e) {
      debugPrint('$tag: ❌ 查询好友关系失败: $e');
      rethrow;
    }
  }
}

